home *** CD-ROM | disk | FTP | other *** search
/ Motor Sport Digital Archive Collection 1960s / Motor Sport Digital Archive Collection 1960s.iso / main.swf / scripts / mx / messaging / channels / DirectHTTPChannel.as next >
Encoding:
Text File  |  2008-05-21  |  9.3 KB  |  266 lines
  1. package mx.messaging.channels
  2. {
  3.    import flash.events.ErrorEvent;
  4.    import flash.events.Event;
  5.    import flash.events.IOErrorEvent;
  6.    import flash.events.SecurityErrorEvent;
  7.    import flash.events.TimerEvent;
  8.    import flash.net.URLLoader;
  9.    import flash.net.URLRequest;
  10.    import flash.net.URLRequestHeader;
  11.    import flash.net.URLVariables;
  12.    import mx.core.mx_internal;
  13.    import mx.messaging.Channel;
  14.    import mx.messaging.MessageAgent;
  15.    import mx.messaging.MessageResponder;
  16.    import mx.messaging.errors.ChannelError;
  17.    import mx.messaging.errors.InvalidChannelError;
  18.    import mx.messaging.errors.MessageSerializationError;
  19.    import mx.messaging.messages.HTTPRequestMessage;
  20.    import mx.messaging.messages.IMessage;
  21.    import mx.utils.Translator;
  22.    
  23.    use namespace mx_internal;
  24.    
  25.    public class DirectHTTPChannel extends Channel
  26.    {
  27.       private static var clientCounter:uint;
  28.       
  29.       private static const TRANSLATOR:Translator = Translator.getDefaultInstanceFor(DirectHTTPChannel);
  30.       
  31.       mx_internal var clientId:String;
  32.       
  33.       public function DirectHTTPChannel(param1:String, param2:String = "")
  34.       {
  35.          super(param1,param2);
  36.          if(param2.length > 0)
  37.          {
  38.             throw new InvalidChannelError(TRANSLATOR.textOf("noURIAllowed"));
  39.          }
  40.          mx_internal::clientId = "DirectHTTPChannel" + clientCounter++;
  41.       }
  42.       
  43.       override public function get connected() : Boolean
  44.       {
  45.          return true;
  46.       }
  47.       
  48.       override public function get protocol() : String
  49.       {
  50.          return "http";
  51.       }
  52.       
  53.       override protected function connectTimeoutHandler(param1:TimerEvent) : void
  54.       {
  55.       }
  56.       
  57.       override protected function getMessageResponder(param1:MessageAgent, param2:IMessage) : MessageResponder
  58.       {
  59.          return new DirectHTTPMessageResponder(param1,param2,this,new URLLoader());
  60.       }
  61.       
  62.       override public function setCredentials(param1:String, param2:MessageAgent = null) : void
  63.       {
  64.          throw new ChannelError(TRANSLATOR.textOf("authenticationNotSupported"));
  65.       }
  66.       
  67.       mx_internal function createURLRequest(param1:IMessage) : URLRequest
  68.       {
  69.          var _loc2_:HTTPRequestMessage = null;
  70.          var _loc3_:URLRequest = null;
  71.          var _loc4_:String = null;
  72.          var _loc5_:String = null;
  73.          var _loc6_:Boolean = false;
  74.          var _loc7_:Object = null;
  75.          var _loc8_:Array = null;
  76.          var _loc9_:URLRequestHeader = null;
  77.          var _loc10_:String = null;
  78.          var _loc11_:URLVariables = null;
  79.          var _loc12_:Object = null;
  80.          var _loc13_:String = null;
  81.          _loc2_ = HTTPRequestMessage(param1);
  82.          _loc3_ = new URLRequest();
  83.          _loc4_ = _loc2_.url;
  84.          _loc5_ = null;
  85.          _loc3_.contentType = _loc2_.contentType;
  86.          _loc6_ = _loc3_.contentType == HTTPRequestMessage.CONTENT_TYPE_XML || _loc3_.contentType == HTTPRequestMessage.CONTENT_TYPE_SOAP_XML;
  87.          _loc7_ = _loc2_.httpHeaders;
  88.          if(_loc7_)
  89.          {
  90.             _loc8_ = [];
  91.             for(_loc10_ in _loc7_)
  92.             {
  93.                _loc9_ = new URLRequestHeader(_loc10_,_loc7_[_loc10_]);
  94.                _loc8_.push(_loc9_);
  95.             }
  96.             _loc3_.requestHeaders = _loc8_;
  97.          }
  98.          if(!_loc6_)
  99.          {
  100.             _loc11_ = new URLVariables();
  101.             _loc12_ = _loc2_.body;
  102.             for(_loc13_ in _loc12_)
  103.             {
  104.                _loc11_[_loc13_] = _loc2_.body[_loc13_];
  105.             }
  106.             _loc5_ = _loc11_.toString();
  107.          }
  108.          if(_loc2_.method == HTTPRequestMessage.POST_METHOD || _loc6_)
  109.          {
  110.             _loc3_.method = "POST";
  111.             if(_loc3_.contentType == HTTPRequestMessage.CONTENT_TYPE_FORM)
  112.             {
  113.                _loc3_.data = _loc5_;
  114.             }
  115.             else
  116.             {
  117.                _loc3_.data = _loc2_.body;
  118.             }
  119.          }
  120.          else if(Boolean(_loc5_) && _loc5_ != "")
  121.          {
  122.             _loc4_ += _loc4_.indexOf("?") > -1 ? "&" : "?";
  123.             _loc4_ = _loc4_ + _loc5_;
  124.          }
  125.          _loc3_.url = _loc4_;
  126.          return _loc3_;
  127.       }
  128.       
  129.       override protected function internalSend(param1:MessageResponder) : void
  130.       {
  131.          var httpMsgResp:DirectHTTPMessageResponder = null;
  132.          var urlRequest:URLRequest = null;
  133.          var urlLoader:URLLoader = null;
  134.          var msgResp:MessageResponder = param1;
  135.          httpMsgResp = DirectHTTPMessageResponder(msgResp);
  136.          try
  137.          {
  138.             urlRequest = mx_internal::createURLRequest(httpMsgResp.message);
  139.          }
  140.          catch(e:MessageSerializationError)
  141.          {
  142.             httpMsgResp.agent.fault(e.fault,httpMsgResp.message);
  143.             return;
  144.          }
  145.          urlLoader = httpMsgResp.urlLoader;
  146.          urlLoader.addEventListener(ErrorEvent.ERROR,httpMsgResp.errorHandler);
  147.          urlLoader.addEventListener(IOErrorEvent.IO_ERROR,httpMsgResp.errorHandler);
  148.          urlLoader.addEventListener(SecurityErrorEvent.SECURITY_ERROR,httpMsgResp.securityErrorHandler);
  149.          urlLoader.addEventListener(Event.COMPLETE,httpMsgResp.completeHandler);
  150.          urlLoader.load(urlRequest);
  151.       }
  152.       
  153.       override protected function internalConnect() : void
  154.       {
  155.          connectSuccess();
  156.       }
  157.    }
  158. }
  159.  
  160. import flash.events.ErrorEvent;
  161. import flash.events.Event;
  162. import flash.events.IOErrorEvent;
  163. import flash.events.SecurityErrorEvent;
  164. import flash.net.URLLoader;
  165. import mx.core.mx_internal;
  166. import mx.messaging.MessageAgent;
  167. import mx.messaging.MessageResponder;
  168. import mx.messaging.messages.AcknowledgeMessage;
  169. import mx.messaging.messages.ErrorMessage;
  170. import mx.messaging.messages.HTTPRequestMessage;
  171. import mx.messaging.messages.IMessage;
  172. import mx.utils.Translator;
  173.  
  174. use namespace mx_internal;
  175.  
  176. class DirectHTTPMessageResponder extends MessageResponder
  177. {
  178.    private static const TRANSLATOR:Translator = Translator.getMessagingInstance();
  179.    
  180.    public var urlLoader:URLLoader;
  181.    
  182.    private var clientId:String;
  183.    
  184.    public function DirectHTTPMessageResponder(param1:MessageAgent, param2:IMessage, param3:DirectHTTPChannel, param4:URLLoader)
  185.    {
  186.       super(param1,param2,param3);
  187.       this.urlLoader = param4;
  188.       clientId = param3.mx_internal::clientId;
  189.    }
  190.    
  191.    public function completeHandler(param1:Event) : void
  192.    {
  193.       var _loc2_:AcknowledgeMessage = null;
  194.       result(null);
  195.       _loc2_ = new AcknowledgeMessage();
  196.       _loc2_.clientId = clientId;
  197.       _loc2_.correlationId = message.messageId;
  198.       _loc2_.body = URLLoader(param1.target).data;
  199.       agent.acknowledge(_loc2_,message);
  200.    }
  201.    
  202.    override protected function requestTimedOut() : void
  203.    {
  204.       var _loc1_:AcknowledgeMessage = null;
  205.       urlLoader.removeEventListener(ErrorEvent.ERROR,errorHandler);
  206.       urlLoader.removeEventListener(IOErrorEvent.IO_ERROR,errorHandler);
  207.       urlLoader.removeEventListener(SecurityErrorEvent.SECURITY_ERROR,securityErrorHandler);
  208.       urlLoader.removeEventListener(Event.COMPLETE,completeHandler);
  209.       urlLoader.close();
  210.       status(null);
  211.       _loc1_ = new AcknowledgeMessage();
  212.       _loc1_.clientId = clientId;
  213.       _loc1_.correlationId = message.messageId;
  214.       _loc1_.headers[AcknowledgeMessage.ERROR_HINT_HEADER] = true;
  215.       agent.acknowledge(_loc1_,message);
  216.       agent.fault(createRequestTimeoutErrorMessage(),message);
  217.    }
  218.    
  219.    public function errorHandler(param1:Event) : void
  220.    {
  221.       var _loc2_:AcknowledgeMessage = null;
  222.       var _loc3_:ErrorMessage = null;
  223.       var _loc4_:* = null;
  224.       status(null);
  225.       _loc2_ = new AcknowledgeMessage();
  226.       _loc2_.clientId = clientId;
  227.       _loc2_.correlationId = message.messageId;
  228.       _loc2_.headers[AcknowledgeMessage.ERROR_HINT_HEADER] = true;
  229.       agent.acknowledge(_loc2_,message);
  230.       _loc3_ = new ErrorMessage();
  231.       _loc3_.clientId = clientId;
  232.       _loc3_.correlationId = message.messageId;
  233.       _loc3_.faultCode = "Server.Error.Request";
  234.       _loc3_.faultString = TRANSLATOR.textOf("httpRequestError");
  235.       _loc4_ = param1.toString();
  236.       if(message is HTTPRequestMessage)
  237.       {
  238.          _loc4_ += ". URL: ";
  239.          _loc4_ = _loc4_ + HTTPRequestMessage(message).url;
  240.       }
  241.       _loc3_.faultDetail = TRANSLATOR.textOf("httpRequestError.details",_loc4_);
  242.       _loc3_.rootCause = param1;
  243.       agent.fault(_loc3_,message);
  244.    }
  245.    
  246.    public function securityErrorHandler(param1:Event) : void
  247.    {
  248.       var _loc2_:AcknowledgeMessage = null;
  249.       var _loc3_:ErrorMessage = null;
  250.       status(null);
  251.       _loc2_ = new AcknowledgeMessage();
  252.       _loc2_.clientId = clientId;
  253.       _loc2_.correlationId = message.messageId;
  254.       _loc2_.headers[AcknowledgeMessage.ERROR_HINT_HEADER] = true;
  255.       agent.acknowledge(_loc2_,message);
  256.       _loc3_ = new ErrorMessage();
  257.       _loc3_.clientId = clientId;
  258.       _loc3_.correlationId = message.messageId;
  259.       _loc3_.faultCode = "Channel.Security.Error";
  260.       _loc3_.faultString = TRANSLATOR.textOf("securityError");
  261.       _loc3_.faultDetail = TRANSLATOR.textOf("securityError.details",message.destination);
  262.       _loc3_.rootCause = param1;
  263.       agent.fault(_loc3_,message);
  264.    }
  265. }
  266.